package com.young.testcoroutine

import kotlinx.coroutines.*
import org.junit.Test
import kotlin.coroutines.*

/**
 * Author：young
 * .
 * Time： 2022/9/12 12:29 周一
 * .
 * Desc：基础使用
 */
class CoroutineTest01 {

    /**
     * 基础的协程创建
     */
    @Test
    fun testCoroutineBase() = runBlocking {
        // 协程体（里面的协程上下文，保存了挂起点的信息）
        val continuation: Continuation<Unit> = suspend {
            11
        }.createCoroutine(object : Continuation<Int> {
            override val context: CoroutineContext
                get() = EmptyCoroutineContext

            override fun resumeWith(result: Result<Int>) {
                println("my result ${result}")
            }
        })

        // 启动协程
        continuation.resume(Unit)
    }


    /**
     * 测试协程构建
     *
     * runBlocking 将我们的主线程包装成协程
     */
    @Test
    fun test_coroutine_builder() = runBlocking {
        // 使用 launch 构建协程
        val job1 = launch {
            delay(200)
            println("job1 完成了")
        }
        // 使用 async 构建协程
        val job2 = async {
            delay(200)
            println("job2 完成了")
            "我是job2返回结果"
        }

        // 等待 job2 的返回结果
        println(job2.await())
    }


    /**
     * 等待协程的完成(launch 启动的协程)
     */
    @Test
    fun testCoroutineJoin() = runBlocking {
        val job1 = launch {
            delay(200)
            println("协程 1 完成了")
        }
        job1.join()
        val job2 = launch {
            delay(200)
            println("协程 2 完成了")
        }

        val job3 = launch {
            delay(200)
            println("协程 3 完成了")
        }
    }

    /**
     * 等待协程的完成(async 启动的协程)
     */
    @Test
    fun testCoroutineAwait() = runBlocking {
        val job1 = async {
            delay(200)
            println("协程 1 完成了")
        }
        job1.await()
        val job2 = async {
            delay(200)
            println("协程 2 完成了")
        }

        val job3 = async {
            delay(200)
            println("协程 3 完成了")
        }
    }

}